package org.javahispano.javacup.tacticas_aceptadas.LucasTG;

import java.awt.image.ConvolveOp;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import org.javahispano.javacup.modelo.Comando;
import org.javahispano.javacup.modelo.ComandoGolpearBalon;
import org.javahispano.javacup.modelo.ComandoIrA;
import org.javahispano.javacup.modelo.Constantes;
import org.javahispano.javacup.modelo.JugadorDetalle;
import org.javahispano.javacup.modelo.Posicion;
import org.javahispano.javacup.modelo.SituacionPartido;

public class Puesto {

    public static boolean puedeRematar(int[] puedenRematar, int jugador) {
        boolean existe = false;
        for (int tmp : puedenRematar) {
            if (tmp == jugador) {
                existe = true;
            }
        }
        return existe;
    }

    public static int buscarArquero(JugadorDetalle[] jugadores) {
        for (int i = 0; i < 11; i++) {
            if (jugadores[i].esPortero()) {
                return i;
            }
        }
        return 0;
    }

    public static boolean hayPaseAtras(Estrategia estrategiaSimple, SituacionPartido sp,
            int id_Jugador, Jugador[] jugadores) {
        int arquero = buscarArquero(sp.detalleJugadoresRivales());
        int companero = jugadores[id_Jugador].getPasarAJugador();
        if ((sp.rivales()[arquero].distancia(sp.misJugadores()[id_Jugador]) < Constantes.DISTANCIA_SAQUE) ||
                (Math.abs(sp.rivales()[arquero].getX()) - Math.abs(sp.misJugadores()[id_Jugador].getX())) > (Math.abs(sp.rivales()[arquero].getX()) - Math.abs(sp.misJugadores()[companero].getX())) ||
                (Math.abs(sp.rivales()[arquero].getX()) - Math.abs(Constantes.centroArcoSup.getX())) < (Constantes.LARGO_ARCO / 4)) {
            return false;
        }
        return true;
    }

    public static ComandoGolpearBalon remateSeguro(Estrategia estrategiaSimple, SituacionPartido sp,
            int id_Jugador) {
        int arquero = buscarArquero(sp.detalleJugadoresRivales());
        Posicion palo = new Posicion(Constantes.posteIzqArcoSup.getX() + 0.4, Constantes.posteIzqArcoSup.getY());
        if (sp.rivales()[arquero].getX() < 0) {
            palo = new Posicion(Constantes.posteIzqArcoSup.getX() - 0.4, Constantes.posteIzqArcoSup.getY());
        }
        double angulo = calcularAnguloRemata(palo, sp.misJugadores()[id_Jugador], Constantes.REMATE_VELOCIDAD_MAX, sp.alturaBalon());
        //double distancia = sp.misJugadores()[id_Jugador].distancia(palo);
        //System.err.println("Angulo:"+String.valueOf(angulo)+" Distancia:"+String.valueOf(distancia));
        if (Constantes.ANGULO_VERTICAL_MAX < angulo) {
            angulo = Constantes.ANGULO_VERTICAL_MAX;
        }
        if (angulo == 0.0) {
            angulo = 20;
        }
        return new ComandoGolpearBalon(id_Jugador, palo, Constantes.REMATE_VELOCIDAD_MAX, angulo);
    }

    public static ComandoGolpearBalon paseSeguro(Estrategia estrategiaSimple, SituacionPartido sp, Posicion lugar,
            int id_Jugador) {
        double angulo = calcularAnguloPase(lugar, sp.misJugadores()[id_Jugador]);
        Posicion desviacionRivales = desviacionRivales(lugar, sp.misJugadores()[id_Jugador], sp);
        lugar.setPosicion(lugar.getX() + desviacionRivales.getX(), lugar.getY() + desviacionRivales.getY());
        double fuerza = calcularFuerza(lugar, sp.misJugadores()[id_Jugador]);
        //System.err.println("Angulo:"+String.valueOf(angulo)+" Fuerza:"+String.valueOf(fuerza)+" distancia: "+String.valueOf(lugar.distancia(sp.misJugadores()[id_Jugador])));
        angulo = (fuerza - 1) * angulo;
        //System.err.println("Angulo*Fuerza:"+String.valueOf(angulo));
        if (Constantes.ANGULO_VERTICAL_MAX < angulo) {
            angulo = Constantes.ANGULO_VERTICAL_MAX;
        }
        return new ComandoGolpearBalon(id_Jugador, lugar, fuerza, angulo);
    }

    /**
     *
     * @param lugar
     * @param (lugar=destino,posicion = origen)
     * @return double de fuerza
     */
    public static double calcularFuerza(Posicion lugar, Posicion posicion) {
        double distancia = posicion.distancia(lugar);
        double velocidad = (Constantes.REMATE_VELOCIDAD_MIN) + (distancia * 0.01);
        if (Constantes.REMATE_VELOCIDAD_MAX < velocidad) {
            velocidad = Constantes.REMATE_VELOCIDAD_MAX;
        }
        return velocidad;
    }

    private static Posicion desviacionRivales(Posicion lugar,
            Posicion posicion, SituacionPartido sp) {
        int rivalCercano = lugar.indiceMasCercano(sp.rivales());
        double difX = Constantes.DISTANCIA_PENAL;
        double difY = Constantes.DISTANCIA_PENAL;
        if (sp.rivales()[rivalCercano].getX() > lugar.getX()) {
            difX = difX * (-1);
        }
        if (sp.rivales()[rivalCercano].getY() > lugar.getY()) {
            difY = difY * (-1);
        }
        Posicion desvia = new Posicion(difX, difY);
        return desvia;
    }

    /*public static double calcularAnguloRemata(Posicion palo, Posicion posicion) {
    double x = posicion.distancia(palo);
    double y = Constantes.ALTO_ARCO;
    double r = Math.hypot(x, y);
    double aRad = Math.atan2(y, x);
    double a = Math.toDegrees(aRad);
    a = a*(1+Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE+Constantes.G);
    return a;
    }*/
    public static double calcularAnguloRemata(Posicion palo, Posicion posicion, double fuerza, double alturaBalon) {
        double angConvert = Math.PI / 180d;

        //double error = 0.0;
        //error = Constantes.getErrorAngular(error);//obtiene el error angular
        //double angulo = posicion.angulo(palo);//calcula el angulo
        //Random rand = new Random();//random para la aleatoriedad
        //angulo = angulo + (rand.nextDouble() * error - error / 2) * Math.PI;//calcula el angulo destino
        //double vel = fuerza * Constantes.getVelocidadRemate(1);//calcula la velocidad del remate

        double anguloPrevio = ((Constantes.ALTO_ARCO + Constantes.G - alturaBalon) / (fuerza * Constantes.getVelocidadRemate(1)));
        anguloPrevio = Math.round(anguloPrevio / Constantes.G) * Constantes.G;
        anguloPrevio = anguloPrevio / angConvert;
        double angVer = Math.min(anguloPrevio, Constantes.ANGULO_VERTICAL_MAX);
        angVer = Math.max(angVer, 0);

//          double balonDz = 0.0;
//          double balonDy = 0.0;
//        angVer = angVer * angConvert; (angVerObtenido/angConvert=angVerMio)
//        if (vel != 0) {//si el remate tiene velocidad
//            vel = vel * Math.cos(angVer);
//            double balonDz = Math.round(vel * Math.sin(angVer)/ Constantes.G) * Constantes.G;
//            //calcula la velocidad en el plano x/y
//            balonDx = Math.cos(angulo) * vel;
//            balonDy = Math.sin(angulo) * vel;
//            //establece la altura inicial en cero
//            alturaBalon = 0;
//        }
//         double alturaBalon =  Constantes.ALTO_ARCO;
//         alturaBalon = Math.round(alturaBalon + balonDz / Constantes.G) * Constantes.G;
        // balon = balon.moverPosicion(balonDx, balonDy);//new Posicion(x + balonDx, y + balonDy);
//          balonDz = Math.round(balonDz - Constantes.G / Constantes.G) * Constantes.G;
        //         balonDx = balonDx * Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE;
        //         balonDy = balonDy * Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE;

        /*double x = posicion.distancia(palo);
        double y = Constantes.ALTO_ARCO+(x*Constantes.G);
        double r = Math.hypot(y,x);
        double aRad = Math.atan2(x,y);
        double a = Math.toDegrees(aRad);
        a = a*(1+Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE);*/

        //return angVer;

        double distancia = posicion.distancia(palo);
        double anguloOtro = ((Constantes.ALTO_ARCO + Constantes.G - alturaBalon) / (fuerza * Constantes.getVelocidadRemate(1) * Math.hypot((Constantes.ALTO_ARCO + (Constantes.G * distancia) - alturaBalon), distancia)));
        //anguloOtro = Math.round(anguloOtro/Constantes.G)*Constantes.G;
        anguloOtro = anguloOtro / angConvert;
        anguloOtro = Math.min(anguloOtro, Constantes.ANGULO_VERTICAL_MAX);
        anguloOtro = Math.max(anguloOtro, 0);
        return Math.toDegrees(anguloOtro);
    }

    public static double calcularAnguloPase(Posicion palo, Posicion posicion) {
        double x = posicion.distancia(palo);
        double y = Constantes.ALTO_ARCO;
        double r = Math.hypot(x, y);
        double aRad = Math.atan2(y + r, x);
        double a = Math.toDegrees(aRad);
        a = a * (Constantes.FACTOR_DISMINUCION_VEL_BALON_AIRE + Constantes.G);
        return a;
    }

    public double redondeaMultiplo(double valor, double divisor) {
        return Math.round(valor / divisor) * divisor;
    }

    public static int[] meGanoElFondo(SituacionPartido sp, int id_Jugador) {
        int[] picheros = new int[11];
        Posicion[] pos = sp.rivales();
        for (int i = 0; i < 11; i++) {
            if (pos[i].getY() < sp.misJugadores()[id_Jugador].getY()) {
                picheros[i] = i;
            } else {
                picheros[i] = 999;
            }
        }
        return picheros;
    }

    public static boolean alguienGanoElFondo(SituacionPartido sp,
            int id_Jugador) {
        Posicion[] pos = sp.rivales();
        for (int i = 0; i < 11; i++) {
            if (pos[i].getY() < sp.misJugadores()[id_Jugador].getY()) {
                return true;
            }
        }
        return false;
    }

    static class Punta extends Puesto {

        public static List<Comando> generarComandos(Estrategia estrategiaSimple,
                SituacionPartido sp, int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            Posicion[] pos = sp.misJugadores();
            if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                if (pos[id_Jugador].distancia(Constantes.centroArcoSup) < Constantes.ANCHO_AREA_GRANDE) {
                    comandos2.add(remateSeguro(estrategiaSimple, sp, id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                } else {
                    if (pos[jugadores[id_Jugador].getPasarAJugadorSuplente()].distancia(pos[id_Jugador]) > pos[jugadores[id_Jugador].getPasarAJugador()].distancia(pos[id_Jugador])) {
                        comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    } else {
                        comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugadorSuplente()], id_Jugador));
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    }
                }
            } else {
                if (sp.balon().getY() < 0) {
                    if (sp.balon().distancia(pos[id_Jugador]) < Constantes.DISTANCIA_PENAL) {
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    } else {
                        Posicion linea = new Posicion(sp.misJugadores()[id_Jugador].getX(), sp.balon().getY());
                        comandos2.add(new ComandoIrA(id_Jugador, linea));
                    }
                } else {
                    double ancho = Math.abs(estrategiaSimple.getPosiciones()[id_Jugador].getX()) - Math.abs(sp.balon().getX());
                    if ((sp.balon().distancia(pos[id_Jugador]) < Constantes.ANCHO_AREA_GRANDE) & (ancho < Constantes.ANCHO_CAMPO_JUEGO / 4)) {
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    } else {
                        Posicion linea = new Posicion(estrategiaSimple.getPosiciones()[id_Jugador].getX(), sp.balon().getY());
                        comandos2.add(new ComandoIrA(id_Jugador, linea));
                    }
                }
            }

            return comandos2;
        }
    }

    static class Saguero extends Puesto {

        public static List<Comando> generarComandos(Estrategia estrategiaSimple,
                SituacionPartido sp, int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                int rivalCercano = sp.misJugadores()[jugadores[id_Jugador].getPasarAJugador()].indiceMasCercano(sp.rivales());
                if (sp.rivales()[rivalCercano].distancia(sp.misJugadores()[jugadores[id_Jugador].getPasarAJugador()]) > (Constantes.DISTANCIA_PENAL / 2)) {
                    comandos2.add(paseSeguro(estrategiaSimple, sp, sp.misJugadores()[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                } else {
                    if (sp.misJugadores()[id_Jugador].getX() > estrategiaSimple.getPosiciones()[id_Jugador].getX()) {
                        double fuerza = calcularFuerza(Constantes.cornerSupIzq, sp.misJugadores()[id_Jugador]);
                        comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.cornerSupIzq, fuerza, 40));
                        comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    } else {
                        double fuerza = calcularFuerza(Constantes.cornerSupDer, sp.misJugadores()[id_Jugador]);
                        comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.cornerSupDer, fuerza, 40));
                        comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    }
                }
            } else {
                if ((estrategiaSimple.getPosiciones()[id_Jugador].distancia(sp.balon()) < (Constantes.DISTANCIA_SAQUE)) || (estrategiaSimple.getPosiciones()[id_Jugador].getY() < sp.balon().getY())) {
                    if (alguienGanoElFondo(sp, id_Jugador)) {
                        int[] rivales = meGanoElFondo(sp, id_Jugador);
                        int cant = 0;
                        for (int i = 0; i < 11; i++) {
                            if (rivales[i] != 999) {
                                cant = cant + 1;
                            }
                        }
                        int[] excluir = new int[cant];
                        for (int i = 0; i < 11; i++) {
                            if (rivales[i] != 999) {
                                excluir[cant - 1] = rivales[i];
                                cant = cant - 1;
                            }
                        }
                        int rival = estrategiaSimple.getPosiciones()[id_Jugador].indiceMasCercano(sp.rivales(), excluir);
                        if (rival > -1) {
                            comandos2.add(new ComandoIrA(id_Jugador, sp.rivales()[rival]));
                            comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroCampoJuego, 1, 40));
                        }
                    } else {
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                        comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroCampoJuego, 1, 40));
                    }
                } else {
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroCampoJuego, 1, 40));
                }
            }
            return comandos2;
        }
    }

    static class Lateral extends Puesto {

        public static List<Comando> generarComandos(Estrategia estrategiaSimple,
                SituacionPartido sp, int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                int rivalCercano = sp.misJugadores()[jugadores[id_Jugador].getPasarAJugador()].indiceMasCercano(sp.rivales());
                if (sp.rivales()[rivalCercano].distancia(sp.misJugadores()[jugadores[id_Jugador].getPasarAJugador()]) > (Constantes.DISTANCIA_PENAL / 2)) {
                    comandos2.add(paseSeguro(estrategiaSimple, sp, sp.misJugadores()[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                } else {
                    if (sp.misJugadores()[id_Jugador].getX() > estrategiaSimple.getPosiciones()[id_Jugador].getX()) {
                        double fuerza = calcularFuerza(Constantes.cornerSupIzq, sp.misJugadores()[id_Jugador]);
                        comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.cornerSupIzq, fuerza, 40));
                        comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    } else {
                        double fuerza = calcularFuerza(Constantes.cornerSupDer, sp.misJugadores()[id_Jugador]);
                        comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.cornerSupDer, fuerza, 40));
                        comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    }
                }
            } else {
                if (estrategiaSimple.getPosiciones()[id_Jugador].distancia(sp.balon()) < (Constantes.ANCHO_CAMPO_JUEGO / 3)) {
                    comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroCampoJuego, 1, 40));
                } else {
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroCampoJuego, 1, 40));
                }
            }
            return comandos2;
        }
    }

    static class TodasATal extends Puesto {

        public static List<Comando> generarComandos(
                EstrategiaSimple estrategiaSimple, SituacionPartido sp,
                int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            ;
            if (Constantes.ANCHO_AREA_GRANDE < sp.balon().distancia(sp.misJugadores()[id_Jugador])) {
                comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
            } else {
                if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                    comandos2.add(paseSeguro(estrategiaSimple, sp, sp.misJugadores()[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                } else {
                    comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                }
            }
            return comandos2;
        }
    }

    static class VolanteOfensivo extends Puesto {

        public static List<Comando> generarComandos(Estrategia estrategiaSimple,
                SituacionPartido sp, int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            Posicion[] pos = sp.misJugadores();
            if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                if (pos[id_Jugador].distancia(Constantes.centroArcoSup) < (Constantes.ANCHO_AREA_GRANDE * 2)) {
                    comandos2.add(remateSeguro(estrategiaSimple, sp, id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                } else {
                    for (int j : pos[id_Jugador].indicesMasCercanos(pos, id_Jugador)) {
                        if (pos[j].getY() > pos[id_Jugador].getY()) {
                            comandos2.add(paseSeguro(estrategiaSimple, sp, pos[id_Jugador], id_Jugador));
                            comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                            break;
                        }

                    }
                }
            } else {
                if (sp.balon().getY() < estrategiaSimple.getPosiciones()[id_Jugador].getY()) {
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                } else {
                    comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                }
            }

            return comandos2;
        }
    }

    static class Enganche extends Puesto {

        public static List<Comando> generarComandos(Estrategia estrategiaSimple,
                SituacionPartido sp, int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            Posicion[] pos = sp.misJugadores();
            if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                if (pos[id_Jugador].distancia(Constantes.centroArcoSup) < (Constantes.ANCHO_AREA_GRANDE + 2)) {
                    comandos2.add(remateSeguro(estrategiaSimple, sp, id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                } else {
                    if (pos[jugadores[id_Jugador].getPasarAJugadorSuplente()].distancia(pos[id_Jugador]) > pos[jugadores[id_Jugador].getPasarAJugador()].distancia(pos[id_Jugador])) {
                        comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    } else {
                        comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugadorSuplente()], id_Jugador));
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    }
                }
            } else {
                if (sp.balon().getY() < (estrategiaSimple.getPosiciones()[id_Jugador].getY() - Constantes.DISTANCIA_PENAL)) {
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                } else {
                    comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                    comandos2.add(paseSeguro(estrategiaSimple, sp, pos[jugadores[id_Jugador].getPasarAJugador()], id_Jugador));
                }
            }

            return comandos2;
        }
    }

    static class Arquero extends Puesto {

        public static List<Comando> generarComandos(
                Estrategia estrategiaSimple, SituacionPartido sp,
                int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            ;
            if ((sp.balon().getY() > Constantes.centroCampoJuego.getY()) ||
                    (sp.balon().getX() < Constantes.cornerInfIzq.getX() + 10) ||
                    (sp.balon().getX() > Constantes.cornerInfDer.getX() - 10)) {
                comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroCampoJuego, 1, Constantes.ANGULO_VERTICAL_MAX - 10));
            } else {
                if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                    comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroCampoJuego, 1, Constantes.ANGULO_VERTICAL_MAX - 10));
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                } else {
                    comandos2 = dondeMeParo(sp, id_Jugador, estrategiaSimple);
                }
            }
            return comandos2;
        }

        private static List<Comando> dondeMeParo(SituacionPartido sp, int id_jugador, Estrategia estrategia) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            ;
            if (sp.puedenRematarRival().length == 0) {
                if (((sp.balon().getY() - sp.misJugadores()[id_jugador].getY()) < (Constantes.DISTANCIA_PENAL)) &
                        ((Constantes.ANCHO_AREA_GRANDE * -1) < sp.balon().getY())) {
                    comandos2.add(new ComandoIrA(id_jugador, sp.balon()));
                    comandos2.add(new ComandoGolpearBalon(id_jugador, Constantes.centroCampoJuego, 1, Constantes.ANGULO_VERTICAL_MAX - 10));
                } else {
                    Posicion offsideDer = new Posicion(Constantes.cornerInfDer.getX(), sp.misJugadores()[id_jugador].getY());
                    Posicion offsideIzq = new Posicion(Constantes.cornerInfIzq.getX(), sp.misJugadores()[id_jugador].getY());
                    Posicion interseccion = Posicion.Interseccion(sp.balon(), Constantes.centroArcoInf, offsideDer, offsideIzq);
                    comandos2.add(new ComandoIrA(id_jugador, interseccion));
                    comandos2.add(new ComandoGolpearBalon(id_jugador, Constantes.centroCampoJuego, 1, Constantes.ANGULO_VERTICAL_MAX - 10));
                }
            } else {
                double alteradobalonX = sp.misJugadores()[id_jugador].getX() + 0.01;
                double alteradobalonY = sp.misJugadores()[id_jugador].getY() + 0.01;

                double alteradobalonXAnt = Constantes.posteIzqArcoInf.getX() + 0.01;
                double alteradobalonYAnt = Constantes.posteIzqArcoInf.getY() + 0.01;
                double xTrayectoria = (alteradobalonX / alteradobalonXAnt) * (Constantes.cornerInfDer.getY() * (alteradobalonY / alteradobalonYAnt));
                Posicion trayectoria = new Posicion(Constantes.cornerInfDer.getX(), xTrayectoria);
                Posicion interseccion = Posicion.Interseccion(sp.balon(), Constantes.centroArcoInf, trayectoria, Constantes.posteIzqArcoInf);
                if (sp.balon().getX() > 0) {
                    alteradobalonXAnt = Constantes.posteDerArcoInf.getX() + 0.01;
                    alteradobalonYAnt = Constantes.posteDerArcoInf.getY() + 0.01;
                    xTrayectoria = (alteradobalonX / alteradobalonXAnt) * (Constantes.cornerInfIzq.getY() * (alteradobalonY / alteradobalonYAnt));
                    trayectoria = new Posicion(Constantes.cornerInfIzq.getX(), xTrayectoria);
                    interseccion = Posicion.Interseccion(sp.balon(), Constantes.centroArcoInf, trayectoria, Constantes.posteDerArcoInf);
                }

                /*
                Posicion offsideDer= new Posicion(Constantes.cornerInfDer.getX(),sp.misJugadores()[id_jugador].getY());
                Posicion offsideIzq= new Posicion(Constantes.cornerInfIzq.getX(),sp.misJugadores()[id_jugador].getY());
                double alteradobalonX = sp.balon().getX()+ 0.0001;
                double alteradobalonXAnt = estrategia.getBalonAnterior().getX() + 0.0001;
                double alteradobalonY = sp.balon().getY()+ 0.0001;
                double alteradobalonYAnt = estrategia.getBalonAnterior().getY() + 0.0001;
                double xTrayectoria = (alteradobalonX/alteradobalonXAnt) * (Constantes.centroArcoInf.getY()*(alteradobalonY/alteradobalonYAnt));
                Posicion trayectoria = new Posicion(xTrayectoria,Constantes.centroArcoInf.getY());
                Posicion interseccion = Posicion.Interseccion(sp.balon(),trayectoria, offsideDer , offsideIzq );*/
                comandos2.add(new ComandoIrA(id_jugador, interseccion));
                comandos2.add(new ComandoGolpearBalon(id_jugador, Constantes.centroCampoJuego, 1, Constantes.ANGULO_VERTICAL_MAX - 10));
            }
            return comandos2;
        }
    }

    static class CentroDelantero extends Puesto {

        public static List<Comando> generarComandos(
                Estrategia estrategiaSimple, SituacionPartido sp,
                int id_Jugador, Jugador[] jugadores) {
            List<Comando> comandos2 = new ArrayList<Comando>();
            if (Puesto.puedeRematar(sp.puedenRematar(), id_Jugador)) {
                if (hayPaseAtras(estrategiaSimple, sp, id_Jugador, jugadores)) {
                    int companero = jugadores[id_Jugador].getPasarAJugador();
                    comandos2.add(paseSeguro(estrategiaSimple, sp, sp.misJugadores()[companero], id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, Constantes.centroArcoSup));
                } else {
                    comandos2.add(remateSeguro(estrategiaSimple, sp, id_Jugador));
                    comandos2.add(new ComandoIrA(id_Jugador, Constantes.centroArcoSup));
                }
            } else {
                if (sp.balon().getY() < Constantes.ANCHO_AREA_GRANDE) {
                    comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                    comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroArcoSup, 0.8, Constantes.ANGULO_VERTICAL_MAX / 2));
                } else {
                    if (sp.balon().distancia(estrategiaSimple.getPosiciones()[id_Jugador]) < (Constantes.ANCHO_AREA_GRANDE)) {
                        comandos2.add(new ComandoIrA(id_Jugador, sp.balon()));
                        comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroArcoSup, 0.8, Constantes.ANGULO_VERTICAL_MAX / 2));
                    } else {
                        comandos2.add(new ComandoIrA(id_Jugador, estrategiaSimple.getPosiciones()[id_Jugador]));
                        comandos2.add(new ComandoGolpearBalon(id_Jugador, Constantes.centroArcoSup, 0.8, Constantes.ANGULO_VERTICAL_MAX / 2));
                    }
                }
            }
            return comandos2;
        }
    }
}
